<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        //随机数
        function getUniqueNums(start, end, n) {
            if (!n) n = 1;
            if (start > end) {
                var temp = start;
                start = end;
                end = temp;
            }
            if (start == end) return [0];
            var math = 0;
            var arr = [];
            while (math++ < n) {
                var add = Math.random() * end - Math.random() * start;
                // add= +add.toFixed(3);
                while (add < start || arr.indexOf(add) > -1) {
                    add = Math.random() * end - Math.random() * start;
                    // add= +add.toFixed(3);
                }
                arr.push(add);
            }
            return arr;
        }
        var start = 1;
        var end = 10;
        var n = 12;
        console.log(getUniqueNums(start, end, n));
        //分隔字符串查找字典
        //先把字符串里用到的字典单词全部拿出来，建立一个二维数组，记录下标和单词，按下标进行升序排序，比如leetcode得到的数组是[[0,lee],[0,leet],[4,cod],[4code]]，然后再根据下标重新拼接，0，0，4，4，那么第一个单词是四个字符长度，应该从记录下标为0的新字典中找到一个字符长度为4的拼上去，如果拼接的字符串能和字符串一样的话，返回true，否则返回false，但我在写到拼接那一步时，我怀疑我的思路出现了错误，因为实现起来很麻烦，然后没继续写下去了
        // function wordBreak(s, dict) {
        //     var mode = [];
        //     for (var i = 0; i < dict.length; i++) {
        //         var index = s.indexOf(dict[i]);//无法全部匹配，待修正
        //         if (index > -1) {
        //             // s = s.replace(dict[i], '');无法完全匹配，方案废弃
        //             mode.push([index, dict[i]]);
        //         }
        //     }
        //     //新字典排序,整理下标
        //     function callSort(num, how) {
        //         var max = 0;
        //         while (max++ < num.length) {
        //             for (var i = 1; i < num.length - (max - 1); i++) {
        //                 if (how ? num[i - 1][0] > num[i][0] : num[i - 1][0] < num[i][0]) {
        //                     var temp = num[i];
        //                     num[i] = num[i - 1];
        //                     num[i - 1] = temp;
        //                 }
        //             }
        //         }
        //         return num;
        //     }
        //     callSort(mode, true);
        //     console.log(mode);
        //     var tow = [0];
        //     var check = 0;
        //     //尝试记录字符长度来恢复字符
        //     for (var ma = 0; ma < mode.length; ma++) {
        //         if (mode[ma][0] != check) {
        //             tow.push(mode[ma][0]);
        //             check = mode[ma][0];
        //         }
        //     }
        //     console.log(tow);
        //     var mask = '';
        //     //混乱ing...
        //     for (var i = 0; i < tow.length; i++) {
        //         for (var j = 0; j < mode.length;) {
        //             if (mode[j][1].length == tow[i + 1] && mode[j][0] === tow[i]) {
        //                 mask += mode[j][1];
        //                 j += mode[j][1].length;
        //             } else {
        //                 j++;
        //             }
        //         }
        //     }
        //     console.log(mask);

        //     if (mask === s) return true;
        //     else return false;
        // }
        // console.log(wordBreak("leetcode", ["lee", "cod", "code", "leet"]));
        var wordBreak = function (s, wordDict) {
            // memory(从start开始，组合成功的走到边界的dp[start]才=true)
            const dp = Array(s.length);//创建一个数组
            const hashSet = new Set(wordDict);
            var canBreak = function (start) {
                // start移动到最后一个元素边界，成功找到结束递归
                if (s.length === start) return true;
                //什么时候会未定义
                if (dp[start] !== undefined) return dp[start];
                for (let i = start + 1; i <= s.length; i++) {
                    let str = s.substring(start, i);
                    if (hashSet.has(str) && canBreak(i)) {
                        dp[start] = true;
                        return true;
                    }
                }
                dp[start] = false;
                return false;
            }
            return canBreak(0);
            console.log(dp);
        };
        console.log(wordBreak("leetcode", ["lee", "cod", "code", "leet"]));
        // console.log(wordBreak("",["lee","leet","cod","code"]));
        // console.log(wordBreak("lee",["1","leet","cod","code","e"]));
        // console.log(wordBreak("lee",["1","leet","cod","code","leetco"]));
        //s='leetcodektallcall',dict = ["lee", "cod", "code", "leet","tcod","dek","co","tallcall"];
        //如果优先取字典最长字符匹配的话,在这种情况下，第一次优先取得leet，就无法继续进行后续替换了，第一次应该取lee，然后取co，dek，最后取tallcall，一开始我使用替换法的时候遇到这种情况，每次运算后都要开启新的分叉，感觉像二叉树一样，后面的tallcall如果再分成几个单词，又要开启新的分叉，这种情况应该怎么实现
    </script>
</body>

</html>